In diesem Abschnitt geht es jetzt darum, wo in einem aus mehreren Modulen bestehenden

Programm bestimmte Namen sichtbar sind, gültig sind und auf die Weise eben

Variablen oder Funktionen zugriffbar sind, aufrufbar sind. Dafür gibt es

Gültigkeitsregeln und diese Gültigkeitsregeln legen eben fest,

welche Namen von Variablen und Funktionen, wo im Programm bekannt sind.

Und insgesamt gibt es an der Stelle mehrere Stufen.

Es gibt Namen, die sind im gesamten Programm über alle Modul- und

Funktionsgrenzen hinweg bekannt. Es gibt Namen, die sind global in einem Modul

bekannt, aber auch über Funktionsgrenzen hinweg.

Diese ersten zwei Stufen sind dann die sogenannten globalen Variablen oder

globalen Funktionen. Dann gibt es Variablen, die sind nur lokal innerhalb

einer Funktion bekannt und noch weniger Variablen und Variablen letztendlich,

die sind nur lokal innerhalb eines Blocks bekannt.

Jetzt kann es immer sein, dass in einem engeren Bereich, also in einem weniger

weit umfassenden Bereich, Namen existieren, die es bereits außerhalb auch

schon gab. Und dann ist die grundlegende Regel so, dass bei Namensgleichheit und

Überdeckung von Namen eine lokale Variable innerhalb einer Funktion, die

gleichnamige globale Variable, überdeckt und eine lokale Variable innerhalb eines

Blocks auch immer die gleichnamige globale Variable oder auch gleichnamige

lokale Variable in umgehenden Blöcken überdeckt. Also immer der engere

Sichtbarkeitsbereich überdeckt den äußeren weiteren Sichtbarkeitsbereich.

Schauen wir uns erstmal globale Variablen an. Das sind also Variablen, die im

gesamten Programm gültig sind, über alle Module hinweg. Sie werden außerhalb von

Funktionen definiert und sie sind ab der Zeile, in der sie definiert sind, in der

gesamten Datei zugreifbar. Und globale Variablen, die in anderen Modulen

definiert wurden, müssen vor dem ersten Zugriff bekannt gemacht werden, das

heißt sie müssen deklariert werden. Es muss kein Speicherplatz angelegt werden.

Wenn Sie sich vielleicht noch mal erinnern an die Begriffe Definition und

Deklaration. Bei einer Definition wird eine Variable bekannt gemacht und es wird

Speicherplatz dafür angelegt. Bei einer Deklaration wird nur der Name und der

Typ dem Compiler bekannt gemacht, aber der Speicherplatz kommt von woanders.

Und das wäre in diesem Fall ja so, dass in einem anderen Modul die Definition der

Variablen erfolgt und der Speicherplatz reserviert wird. Und in einem zweiten

Modul wollen Sie dann bloß noch darauf zugreifen, das heißt Sie müssen also im

Compiler nur sagen, da gibt es zum Beispiel, wie hier in dem aufgeführten

Beispiel, zwei Integer-Variablen A und B und eine Character-Variable C. Die kommt

von irgendwo her und die Typen sind eben Integer und Character. Und beim

Zusammenbinden der Module muss dann letztendlich die Referenz auf die

entsprechende Speicherstelle hergestellt werden. Also es gibt ein

anderes Modul, das sagt, okay ich habe eine Variable A und ich habe ein Speicher

dafür und in dem Modul, in dem diese Externdeklaration gemacht wird, wird nur

der Name bekannt gegeben und eben beim Zusammenbinden muss dann dieser

Bezug zur richtigen Speicherstelle dann hergestellt werden. Solche globalen

Variablen sind einerseits natürlich sehr praktisch, weil man also direkt auf

irgendwelche Zustände zugreifen kann, aber wenn Sie sich an das Bild mit dieser

blauen Wolke oben drüber im letzten Abschnitt erinnern, dann ist genau das

das Problem, dass Sie also letztendlich modulübergreifend irgendwelche mehr oder

weniger wilden Zugriffe auf solche Variablen haben. Das Schlimme daran ist,

dass der Zusammenhang zwischen den Daten und den darauf operierenden

Programmcode letztendlich verloren geht. Sie haben tausende Zeilen von Programmcode